package les

import org.apache.el.lang.ELSupport;

class IntegranteController {

	static allowedMethods = [save: "POST", update: "POST", delete: "POST"]

	def index = {
		if (!session.usuarioLogado) {
			redirect(uri: '/usuario/login.gsp')
			return
		}

		redirect(action: "list", params: params)
	}

	def list = {
		if (!session.usuarioLogado) {
			redirect(uri: '/usuario/login.gsp')
			return
		}
		if (!(session.usuarioLogado?.tipo in ['Administrador', 'Jota'])) {
			redirect(uri: '/index.gsp')
			return
		}

		params.max = Math.min(params.max ? params.int('max') : 10, 100)
		params.sort = "nome"

		List lista = Integrante.list(params)
		if (params.buscaTudo) {
			lista = Integrante.findAll(sort: "nome")
		}
		if (params.buscaNome && params.buscaNome != "") {
			lista = Integrante.findAllByNomeIlike("%${params.buscaNome}%", [sort: "nome"])
		}

		[integranteInstanceList: lista, integranteInstanceTotal: Integrante.count(), parametros: params]
	}

	def create = {
		if (!session.usuarioLogado) {
			redirect(uri: '/usuario/login.gsp')
			return
		}
		if (!(session.usuarioLogado?.tipo in ['Administrador', 'Jota'])) {
			redirect(uri: '/index.gsp')
			return
		}

		def integranteInstance = new Integrante()
		integranteInstance.properties = params
		return [integranteInstance: integranteInstance]
	}

	def save = {
		if (!session.usuarioLogado) {
			redirect(uri: '/usuario/login.gsp')
			return
		}
		if (!(session.usuarioLogado?.tipo in ['Administrador', 'Jota'])) {
			redirect(uri: '/index.gsp')
			return
		}

		def parametros = prepararParametros(params)

		if (parametros.erroUsuario) {
			flash.message = parametros.erroUsuario
			Integrante integranteInstance = new Integrante(parametros)
			render(view: "create", model: [integranteInstance: integranteInstance])
			return
		}
		else {
			def integranteInstance = new Integrante(parametros)
			if (integranteInstance.save(flush: true)) {
				if (integranteInstance.conjuge) {
					Integrante conjuge = integranteInstance.conjuge
					conjuge.conjuge = integranteInstance
					conjuge.save(flush: true)
				}
				flash.message = "${message(code: 'default.created.message', args: [message(code: 'integrante.label', default: 'Integrante'), integranteInstance.id])}"
				redirect(action: "show", id: integranteInstance.id)
			}
			else {
				render(view: "create", model: [integranteInstance: integranteInstance])
			}
		}
	}

	def show = {
		if (!session.usuarioLogado) {
			redirect(uri: '/usuario/login.gsp')
			return
		}

		def integranteInstance = Integrante.get(params.id)
		if (!integranteInstance) {
			flash.message = "${message(code: 'default.not.found.message', args: [message(code: 'integrante.label', default: 'Integrante'), params.id])}"
			redirect(action: "list")
		}
		else {
			[integranteInstance: integranteInstance]
		}
	}

	def edit = {
		if (!session.usuarioLogado) {
			redirect(uri: '/usuario/login.gsp')
			return
		}

		def integranteInstance = Integrante.get(params.id)
		if (!integranteInstance) {
			flash.message = "${message(code: 'default.not.found.message', args: [message(code: 'integrante.label', default: 'Integrante'), params.id])}"
			redirect(action: "list")
		}
		else {
			Integrante integr = Integrante.findByUsuario(session.usuarioLogado);
			if (!(integr?.ehCoordenadorDeEquipeDoIntegrante(integranteInstance) || integr?.ehCoordenadorDeCirculoDoIntegrante(integranteInstance) || session.usuarioLogado.tipo in ['Administrador', 'Jota'])) {
				flash.message = "Voce nao tem permissao para editar esse integrante"
				redirect(action: "list")
				return
			}
			return [integranteInstance: integranteInstance]
		}
	}

	def update = {
		if (!session.usuarioLogado) {
			redirect(uri: '/usuario/login.gsp')
			return
		}

		def integranteInstance = Integrante.get(params.id)
		def velhoConjuge = integranteInstance.conjuge
		if (integranteInstance) {
			if (params.version) {
				def version = params.version.toLong()
				if (integranteInstance.version > version) {
					integranteInstance.errors.rejectValue("version", "default.optimistic.locking.failure", [
						message(code: 'integrante.label', default: 'Integrante')]
					as Object[], "Another user has updated this Integrante while you were editing")
					render(view: "edit", model: [integranteInstance: integranteInstance])
					return
				}
			}
			def parametros = prepararParametros(params)

			if (parametros.erroUsuario) {
				flash.message = parametros.erroUsuario
				Integrante integranteUpdate = new Integrante(parametros)
				render(view: "create", model: [integranteInstance: integranteUpdate])
				return
			}

			integranteInstance.properties = parametros
			if (request.getParameter('removerUsuario')) {
				Usuario usuarioARemover = integranteInstance.usuario;
				integranteInstance.usuario = null;
				try {
					usuarioARemover.delete(flush: true)
				}
				catch (org.springframework.dao.DataIntegrityViolationException e) {
				}
			}
			if (!integranteInstance.hasErrors() && integranteInstance.save(flush: true)) {
				if (integranteInstance.conjuge?.id == integranteInstance.id) {
					integranteInstance.conjuge = null;
					integranteInstance.save(flush: true)
				}
				if (integranteInstance.conjuge) {
					Integrante conjuge = integranteInstance.conjuge
					conjuge.conjuge = integranteInstance
					conjuge.save(flush: true)
				}
				if (velhoConjuge && integranteInstance.conjuge != velhoConjuge) {
					velhoConjuge.conjuge = null
					velhoConjuge.save(flush: true)
				}
				flash.message = "${message(code: 'default.updated.message', args: [message(code: 'integrante.label', default: 'Integrante'), integranteInstance.id])}"
				redirect(action: "show", id: integranteInstance.id)
			}
			else {
				render(view: "edit", model: [integranteInstance: integranteInstance])
			}
		}
		else {
			flash.message = "${message(code: 'default.not.found.message', args: [message(code: 'integrante.label', default: 'Integrante'), params.id])}"
			redirect(action: "list")
		}
	}

	def delete = {
		if (!session.usuarioLogado) {
			redirect(uri: '/usuario/login.gsp')
			return
		}
		if (!(session.usuarioLogado?.tipo in ['Administrador', 'Jota'])) {
			redirect(uri: '/index.gsp')
			return
		}

		def integranteInstance = Integrante.get(params.id)
		Integrante conjuge = integranteInstance.conjuge
		ArrayList<Equipe> equipesCoordena = integranteInstance.equipesQueCoordena()
		ArrayList<Equipe> equipesQueEhMembro = integranteInstance.equipesQueEhMembro()
		ArrayList<Circulo> circulosCoordena = integranteInstance.circulosQueCoordena()
		ArrayList<Circulo> circulosQueEhMembro = integranteInstance.circulosQueEhMembro()
		if (integranteInstance) {
			try {
				if (conjuge) {
					conjuge.conjuge = null
					conjuge.save(flush: true)
				}
				for (Equipe equipe : equipesCoordena) {
					equipe.coordenadores.remove(integranteInstance)
					equipe.save(flush: true)
				}
				for (Equipe equipe : equipesQueEhMembro) {
					equipe.membros.remove(integranteInstance)
					equipe.save(flush: true)
				}
				for (Circulo circulo : circulosCoordena) {
					circulo.coordenadores.remove(integranteInstance)
					circulo.save(flush: true)
				}
				for (Circulo circulo : circulosQueEhMembro) {
					circulo.membros.remove(integranteInstance)
					circulo.save(flush: true)
				}
				integranteInstance.delete(flush: true)
				flash.message = "${message(code: 'default.deleted.message', args: [message(code: 'integrante.label', default: 'Integrante'), params.id])}"
				redirect(action: "list")
			}
			catch (org.springframework.dao.DataIntegrityViolationException e) {
				flash.message = "${message(code: 'default.not.deleted.message', args: [message(code: 'integrante.label', default: 'Integrante'), params.id])}"
				redirect(action: "show", id: params.id)
			}
		}
		else {
			flash.message = "${message(code: 'default.not.found.message', args: [message(code: 'integrante.label', default: 'Integrante'), params.id])}"
			redirect(action: "list")
		}
	}

	def prepararParametros(parametros) {
		if (parametros.telefones) {
			List telefonesAInserir = new ArrayList();

			// Quando apenas um telefone (string de 14 caracteres (XX) XXXX.XXXX)
			// eh inserido, Grails estava interpretando como 14 strings diferentes
			// para cada caractere. Entao testa-se se o primeiro 'telefone' eh
			// apenas o parentese
			if (parametros.telefones[0] == '(') {
				telefonesAInserir = [parametros.telefones];
			}
			else {
				for (int i = 0; i < parametros.telefones.size(); i++) {
					if (!parametros.telefones[i].equals("")) {
						telefonesAInserir.add(parametros.telefones[i]);
					}
				}
			}
			parametros.telefones = telefonesAInserir;
		}

		List comunicacoesAInserir = new ArrayList();
		if (parametros.orkut) {
			comunicacoesAInserir.add('Orkut');
		}
		if (parametros.msn) {
			comunicacoesAInserir.add('MSN');
		}
		if (parametros.sms) {
			comunicacoesAInserir.add('SMS');
		}
		if (parametros.emailContato) {
			comunicacoesAInserir.add('E-mail');
		}
		if (parametros.celular) {
			comunicacoesAInserir.add('Celular');
		}
		parametros.comunicacoes = comunicacoesAInserir;

		if (parametros.temConjuge == "sim") {
			parametros.conjuge = Integrante.findByNome(parametros.conjuge);
			if (parametros.novoConjuge) {
				parametros.conjuge = Integrante.findByNome(parametros.novoConjuge);
			}
		}
		else {
			parametros.conjuge = null;
		}

		if (parametros.tocaInstrumento == "nao") {
			parametros.instrumento = '';
		}

		if (parametros.jaFezEncontro == "nao") {
			parametros.encontroFeito = '';
		}

		if (parametros.frequentaOutraReligiao == "nao") {
			parametros.outraReligiao = '';
		}

		if (parametros.comoSoube == "Outros") {
			parametros.comoSoube = parametros.outrosComoSoube;
		}

		if (parametros.temAlergia == "nao") {
			parametros.alergia = '';
		}

		if (parametros.algumaComidaNaoPode == "nao") {
			parametros.comidaNaoPode = '';
		}

		if (parametros.paisFizeramECC == "nao") {
			parametros.paisECC = '';
		}

		if (parametros.precisaAtencaoEspecial == "nao") {
			parametros.atencaoEspecial = '';
		}

		if (parametros.vaiTerUsuario == "sim") {
			if (parametros.usuarioSenha.length() < 5 || parametros.usuarioSenha.length() > 10) {
				parametros.erroUsuario = 'A senha do usuario deve ter entre 5 e 10 caracteres.';
			}
			Usuario usuarioAVincular = new Usuario(parametros.usuarioSenha, parametros.usuarioEmail, parametros.usuarioTipo);
			parametros.usuario = usuarioAVincular
		}

		parametros.remove("temConjuge")
		parametros.remove("removerUsuario")
		parametros.remove("vaiTerUsuario")
		parametros.remove("usuarioSenha")
		parametros.remove("usuarioEmail")
		parametros.remove("usuarioTipo")

		return parametros
	}

	def pegarIntegrantesSemConjuge = {
		List integrantes = Integrante.findAllByConjugeIsNullAndNomeIlike("%${params.query}%")

		// Criar resposta XML
		render(contentType: "text/xml") {
			results() {
				integrantes.each { integrante ->
					result(){
						name(integrante.nome)
						id(integrante.id)
					}
				}
			}
		}
	}

	def prepararLista = {
		if (!session.usuarioLogado) {
			redirect(uri: '/usuario/login.gsp')
			return
		}
	}

	def imprimirLista = {
		if (!session.usuarioLogado) {
			redirect(uri: '/usuario/login.gsp')
			return
		}
		
		if ((params.filtro == 'encontro' && !params.encontroEncontro) ||
			(params.filtro == 'equipe' && !params.equipeEquipe) || 
			(params.filtro == 'circulo' && !params.circuloCirculo)) {
			redirect(uri: '/integrante/listaVazia.gsp')
			return
		}
	}

	def pegarIntegrante = {
		List integrantes = Integrante.findAllByNomeLike("%${params.query}%")

		// Criar resposta XML
		render(contentType: "text/xml") {
			results() {
				integrantes.each { integrante ->
					result(){
						name(integrante.nome)
						id(integrante.id)
					}
				}
			}
		}
	}

	def mapaDeCarona = {
		if (!session.usuarioLogado) {
			redirect(uri: '/usuario/login.gsp')
			return
		}

		Usuario donoDoCarro = Usuario.findByIdLike(session.usuarioLogado.getId())
		Integrante integranteDonoDoCarro = Integrante.findByUsuarioLike(donoDoCarro)

		if (integranteDonoDoCarro == null){
			redirect(uri: '/index.gsp')
			return
		}

		def pos = ""
		def veioDoForm = false


		if (integranteDonoDoCarro?.rua == null){
			redirect(uri: '/index.gsp')
			flash.message = "Coloque um endereço válido para rua, número, cidade e estado"
			return
		}

		String enderecoDonoCarro = "from: ${integranteDonoDoCarro?.rua}, ${integranteDonoDoCarro?.numero} - ${integranteDonoDoCarro?.cidade} - ${integranteDonoDoCarro?.estado}"
		if(params['nomeRua']) {
			def integrante1 = Integrante.findByNomeLike(params['integrante1'])
			def integrante2 = Integrante.findByNomeLike(params['integrante2'])
			def integrante3 = Integrante.findByNomeLike(params['integrante3'])


			String enderecoIntegrante1 = ""
			String enderecoIntegrante2 = ""
			String enderecoIntegrante3 = ""

			if (integrante1?.rua != null)
				enderecoIntegrante1 = "to: ${integrante1?.rua}, ${integrante1?.numero} - ${integrante1?.cidade} - ${integrante1?.estado}"
			if (integrante2?.rua != null)
				enderecoIntegrante2 = "to: ${integrante2?.rua}, ${integrante2?.numero} - ${integrante2?.cidade} - ${integrante2?.estado}"
			if (integrante3?.rua != null)
				enderecoIntegrante3 = "to: ${integrante3?.rua}, ${integrante3?.numero} - ${integrante3?.cidade} - ${integrante3?.estado}"

			String enderecoDoEvento = "to: R. ${params['nomeRua']}, ${params['numero']} - ${params['cidade']} - ${params['estado']}"
			pos = "${enderecoDonoCarro} ${enderecoIntegrante1} ${enderecoIntegrante2} ${enderecoIntegrante3} ${enderecoDoEvento}"
			veioDoForm = true
		}
		[posicao : pos, veioDoForm : veioDoForm]
	}

	def experienciasPassadas = {
		if (!session.usuarioLogado) {
			redirect(uri: '/usuario/login.gsp')
			return
		}
		if (!(session.usuarioLogado?.tipo in ['Administrador', 'Jota'])) {
			redirect(uri: '/index.gsp')
			return
		}

		boolean veioDoForm = false
		Integrante integrante;

		if(params["integrante"]){
			veioDoForm = true
			integrante = Integrante.findByNome(params["integrante"])
			if (integrante == null){
				flash.message = "Escolha um integrante valido"
//				redirect(uri: '/integrante/experienciasPassadas.gsp')
				return
			}
		}
		
				
		[integranteInstance : integrante, veioDoForm : veioDoForm]
	}
}
